﻿#pragma once

#define String char *

// 所有和色谱有关的结构在这里定义，还有公有的设置类型

// 关于用户信息 ------------------------------
typedef struct tagUserInfo
{
    String UName;
    String Corp;
    String Dept;
    String InstName;
    int32_t Level;
    int32_t Access;
    int32_t UserID;
    int32_t nReserve;
} TUserInfo, *PTUserInfo, NEAR *NPTUserInfo, FAR *LPTUserInfo;
typedef const TUserInfo FAR *LPCTUserInfo;

typedef struct tagTInstBaseInfo
{
    char Label[NameLength];
    int32_t FreqIdx;
    double Range;
} TInstBaseInfo;
typedef const TInstBaseInfo FAR *LPCTInstBaseInfo;

// 关于方法 -------------------------------------
typedef struct tagTHandEventItem //????
{
    int32_t Event;
    int32_t Used;
    float t1;
    float v1;
    float t2;
    float v2;
} THandEventItem;
typedef const THandEventItem FAR *LPCTHandEventItem;

typedef struct tagTISTDComponentItem // 内标物表结构
{
    char Name[NameLength];
    float RTime;
    float Window;
} TISTDComponentItem;
typedef const TISTDComponentItem FAR *LPCTISTDComponentItem;

typedef struct tagTComponentItem // 组分表结构
{
    char Name[NameLength]; // x0 -> 0
    float RTime;           // x8 -> 32
    float Window;          // x9 -> 36
    double f0;             // x10 -> 40
    double f1;             // x12 -> 48
    double f2;             // x14 -> 56
    double f3;             // x16 -> 64
    double r;
    int32_t ISTDID;
} TComponentItem;
typedef const TComponentItem FAR *LPCTComponentItem;

typedef struct tagTConcListItem // 组分浓度表结构
{
    char Name[NameLength];
    union
    {
        double Conc;
        struct
        {
            float k;
            float conc;
        };
    };
} TConcListItem, *PTConcListItem, NEAR *NPTConcListItem, FAR *LPTConcListItem;
typedef const TConcListItem FAR *LPCTConcListItem;

typedef struct tagTMultiPeakRec // 重复性表结构
{
    char Name[NameLength]; // 组分名
    int32_t IsIstd;        // 是否为内标组分
    float RTime;           // 保留时间
    float TimeRange;       // 时间范围
    double TimeAvg;        // 保留时间均值
    double TimeRSD;        // 保留时间RSD
    double AreaAvg;        // 面积均值
    double AreaRSD;        // 面积RSD
    double HeightAvg;      // 高度均值
    double HeightRSD;      // 高度RSD
    double ConcAvg;        // 含量均值
    double ConcRSD;        // 含量RSD
    double ConcMin;        // 含量最小值
    double ConcMax;        // 含量最大值
    int32_t Count;
    float RTimes[MAX_SERIES];
} TMultiPeakRec, *PTMultiPeakRec, NEAR *NPTMultiPeakRec, FAR *LPTMultiPeakRec;
typedef const TMultiPeakRec FAR *LPCTMultiPeakRec;
// RSD计算公式：
// 平均值：X = (Σx) / n = (x1+x2+...+xn) / n
// 标准差：SD = sqrt((Σ[(x-X)^2]) / (n-1))
//           = sqrt((Σx^2 - X^2*n) / (n-1))
// 相对标准差：RSD = SD / X *100%

// HPG   //2014-12-xx: ++++++
typedef struct tagTQCItem // QC数据项
{
    char Name[NameLength];   // 组分名/组名
    int32_t ItemType;        // 0-组分, 1-连续组, 2-间断组, 3-未知峰合计, 4-外部组分, 5-主要组成, -1-合计
    float cLower;            // 品控下限
    float cUpper;            // 品控上限
    float dLimit;            // 检出限
    int32_t ConcUnitFactor;  // 浓度单位因子值(0-使用配样信息中指定的含量单位, 2+UNIT_N:%, 3+UNIT_N:‰, 6+UNIT_N:ppm,
                             // 9+UNIT_N:ppb, 12+UNIT_N:ppt)
    int32_t HPGOperator;     // 高纯气专用版限值算符
    float HPGLimitValues[3]; // 高纯气专用版限值
} TQCItem;

typedef struct tagTSynResultItem // 综合结果
{
    char Name[NameLength]; // 组分名/组名
    int32_t Type;          // 0-组分, 1-连续组, 2-间断组, 3-未知峰合计, 4-外部组分, 5-主要组成, -1-合计
    int32_t OkState;       // 0-未检出, 1-偏低, 2-偏高, 3-OK
    union
    {
        struct
        {
            float Tr;   // 保留时间
            float Band; // 带宽
        };
        struct
        {
            float tLower; // 时间下限
            float tUpper; // 时间上限
        };
    };
    float cLower;  // 品控下限
    float cUpper;  // 品控上限
    double Area;   // 组累计峰面积
    double Height; // 组累计峰高
    double Conc;   // 实测含量
    double ConcEx; // 含量扩充(如发热量、TVOC标准状态含量等)
    float dLimit;  // 检出限
    // int32_t     Reserve[7]; //保留字段    //HPG   //2014-12-xx: xxxxxx    //改为:
    int32_t ConcUnitFactor; // 浓度单位因子值(0-使用配样信息中指定的含量单位, 2+UNIT_N:%, 3+UNIT_N:‰, 6+UNIT_N:ppm,
                            // 9+UNIT_N:ppb, 12+UNIT_N:ppt)
    union
    {
        int32_t Reserve[6]; // 保留字段
        struct
        {
            int32_t HPGOperator;     // 高纯气专用版限值算符
            float HPGLimitValues[3]; // 高纯气专用版限值
        };
    };

} TSynResultItem; // sizeof=120=15*8
typedef const TSynResultItem FAR *LPCTSynResultItem;

typedef struct tagTSliceResultItem // 切片结果项
{
    float Time; // 切片时间[sec]
    char nop[4];
    double Area;     // 切片面积[uV.sec]
    double AreaPer;  // 切片面积%
    double TotalPer; // 切片累积面积%
} TSliceResultItem;
typedef const TSliceResultItem FAR *LPCTSliceResultItem;

//----------------------analysis.dll-----------------
typedef struct tagTDLLEPARA
{
    int32_t based;   // 定量基准
    int32_t method;  // 定量方法
    int32_t grouped; // 是否分组
} TDLLEPARA;
typedef const TDLLEPARA FAR *LPCTDLLEPARA;

typedef struct tagTDLLEPINF //  峰处理参数描述
{
    LPVOID epara;  // 峰辨识参数描述 TDLLEPARA *
    LPVOID grpInf; // 分组表描述 TDLLGroupInf *
} TDLLEPINF;
typedef const TDLLEPINF FAR *LPCTDLLEPINF;

// 峰辨识参数描述
typedef struct tagTDLLIPINF
{
    LPVOID ipara;   // 峰辨识参数 TDLLIPARA *
    LPVOID tprgInf; // 时间表描述 TDLLTPRGINF *
} TDLLIPINF;
typedef const TDLLIPINF FAR *LPCTDLLIPINF;

// size=56
typedef struct tagTDLLMETRIC
{
    double enrich;      // 浓缩因子(无单位)          x0 => 0
    double amount;      // 样品量(mol,ml,ul,g,mg)   x2 => 8
    double dilution;    // 稀释量(ml)             x4 => 16
    double injVolume;   // 进样量(ul)            x6 => 24
    int32_t byCalib;    // 是否为标样             x8 => 32
    int32_t concFactor; // 组分浓度(含量)单位因子[2(100:%,mg%ml),6(10^6:ppm),9(10^9:ppb),12(10^12:ppt)]
                        //                     x9 => 36
    int32_t amtK;       // 样品量单位因子[-1(mg),1000(ml),%(0),-1000(g),ul(-1)]
                        //                     x10 => 40
    int32_t istdK;      // 内标量单位因子        x11 => 44
    float columnLength; // 柱长(单位：米)    x12 => 48
    float deadTime;     // 死时间(min)      x13 => 52
} TDLLMETRIC;
typedef const TDLLMETRIC FAR *LPCTDLLMETRIC;

//  峰辨识参数及其描述   -----------------------------------
//  size=16
typedef struct tagTRAWBAG
{
    LPINT head;  // 样品谱图数据缓区头        x0 => 0
    int32_t len; // 谱图数据缓区长           x1 => 4
    LPINT time;  // 时间计数指针 *int32_t       x2 => 8
    PFLOAT freq; //                      x3 => 12
} TRAWBAG;

//  样品数据包
//  size=16
typedef struct tagTSMPBAG
{
    LPVOID metric;       // TDLLMETRIC *metric; 样品计量信息描述  x0 => 0
    LPVOID rawbag;       // RAWBAG    *rawbag; 谱图数据包        x1 => 4
    LPINT Base;          // int32_t  *base; 基线谱图数据缓区头           x2 => 8
    int32_t baseMaxTime; //                                  x3 => 12
} TSMPBAG;
typedef const TSMPBAG FAR *LPCTSMPBAG;

typedef union tagTYPE_UNION
{
    float f;
    int32_t n;
    int32_t b;
    char s[4];
} TYPE_UNION;

// 结果表及其描述   -----------------------------------
// 结果表 size = 184
typedef struct tagTDLLResultListItem
{
    double Area;           // 峰面积(uV*s)  x0 -> 0
    double AreaPer;        // 面积%  x2 -> 8
    double Conc;           // 含量  x4 -> 16
    double Areas;          // 峰起点面积(uV*s)  x6 -> 24
    double Arear;          // 峰顶点面积(uV*s)  x8 -> 32
    double Areae;          // 峰落点面积(uV*s)  x10 -> 40
    double ALeft;          // x12 -> 48
    double ARight;         // x14 -> 56
    int32_t Idno;          // 组份号 x16 -> 64
    char Name[NameLength]; // 组份名 x17 -> 68
    float RTime;           // 保留时间(min.) x25 -> 100
    float Height;          // 峰高(uV) x26 -> 104
    BYTE TypeCode[4];      // 峰类型码 x27 -> 108

    // 新的定义(0x113及之后的版本):
    float W50;        // 半高峰宽(min.) x28 -> 112
    float Sigma5;     // 5Sigma峰宽(min.) x29 -> 116
    float Plates;     // 理论塔片数 = 5.545*(Tr/W50)^2 x30 -> 120
    float Resolution; // 分离度= 2.35478/2*(Tr2-Tr1)/(W50_2+W50_1) x31 -> 124
    float Symmetry;   // USP拖尾因子 = 5%峰高宽/(2*5%峰高的左宽) x32 -> 128
    float M1;         // 统计要素中的平均保留时间 x33 -> 132
    float M2;         // 统计要素中的峰畸变(展宽) x34 -> 136
    union
    {
        TYPE_UNION Reserve1; // 保留字段1 x35 -> 140
        float fts;
    };
    union
    {
        TYPE_UNION Reserve2; // 保留字段2 x36 -> 144
        float fte;
    };
    // float Capacity;   //容量因子k' = (Tr-T0)/T0  (T0为死时间)     Capacity//容量因子
    // float PlatesOK;   //有效塔片数 = [k'/(1+k')]^2 *理论塔片数  Effi    //柱效(理论塔片数)

    // 原结构定义(0x112及之前版本)
    /*float Whalf;      //半高峰宽(min.)
    float   Sigma5;     //5Sigma峰宽(min.)
    float   Effi;       //柱效(理论塔片数)
    float   Effl;       //理论塔片数/米
    float   Effi1;      //柱效(有效塔片数)
    float   Effl1;      //有效塔片数/米
    float   Rs;         //分离度
    float   Du;         //峰对称度(拖尾因子)
    float   Capacity;   //容量因子k' = (Tr-T0)/T0  (T0为死时间)
    */

    int32_t ts; // 峰起点时间(与采样频率有关) x37 -> 148
    float tr;   // 峰顶点时间(与采样频率有关) x38 -> 152
    int32_t te; // 峰落点时间(与采样频率有关) x39 -> 156
    float hs;   // 峰起点高度(uV) x40 -> 160
    float hsv;  // 峰起点与积分基线垂直相交处的高度(uV) x41 -> 164
    float hr;   // 峰顶点高度(uV) x42 -> 168
    float he;   // 峰落点高度(uV) x43 -> 172
    float hev;  // 峰落点与积分基线垂直相交处的高度(uV) x44 -> 176

    TYPE_UNION ReserveX; // 保留字段X x45 -> 180
} TDLLResultListItem;
typedef const TDLLResultListItem FAR *LPCTDLLResultListItem;

// 结果表描述
typedef struct tagTDLLRESINF
{
    TDLLResultListItem *head; // 结果表缓区头指针
    int32_t len;              // 缓区长
    LPINT num;                // 缓区项目数指针 int32_t *
} TDLLRESINF;
typedef const TDLLRESINF FAR *LPCTDLLRESINF;

/*typedef struct tagTFileHead{ //数据文件头定义
    int32_t Version;
    int32_t FileType;
    int32_t CreateTime;
    int32_t ModifyTime;
    int32_t Reserve[4]; //Reserve[0]--修改后数据的偏移, Reserve[1]--修改后数据的版本号
    int32_t NodeOfs[NT_MaxItems];
}TFileHead;*/
typedef struct tagTFileHeadOld // 老的数据文件头定义
{
    int32_t OriginVersion; // 原始数据的版本号
    int32_t FileType;
    int32_t CreateTime;
    int32_t ModifyTime;
    int32_t ModifyOffset;  // 修改后数据的偏移
    int32_t ModifyVersion; // 修改后数据的版本号
    int32_t NTExVersion;   // 数据节点扩充定义的版本号(=0)
    int32_t Reserve;       //(保留字段=0)
    int32_t NodeOfs[NT_MaxItems];
} TFileHeadOld;

enum // 导入数据源定义
{
    IS_NONE = 0, // 无导入的数据源

    IS_DAT = 1, //.dat(二进制格式)
    IS_RAW = 2, //.raw(二进制格式)
    IS_TXT = 3, //.txt(以Tab为分隔符的文本格式)
    IS_CSV = 4, //.csv(以逗点为分隔符的文本格式)
    IS_CDF = 5, //.cdf

    IS_T2K_OFS = 0x10,
    IS_T2000 = 0x10, // T2000
    // IS_T2000IC  = 0x11,
    IS_T2000P = 0x12, // T2000P
    IS_D7900 = 0x13,  // D-7900
    IS_D1010 = 0x14,  // D-1010
};
typedef struct tagTFileHead // 新的数据文件头定义
{
    int32_t OriginVersion; // 原始数据的版本号
    int32_t FileType;
    int32_t CreateTime;
    int32_t ModifyTime;
    int32_t ModifyOffset;  // 修改后数据的偏移
    int32_t ModifyVersion; // 修改后数据的版本号
    int32_t NTExVersion;   // 数据节点扩充定义的版本号(>=0x114)
    int32_t ImportSource;  // 导入数据源(.dat/.raw, .txt/.csv/.txt, T2000系列谱图文件)
    char AIAVersion[8];    // AIA版本(x.x)
    char CDFVersion[8];    // CDF版本(x.x)
    WORD FileStatus;
    BYTE Reserve[2 * 7]; //(保留字段)
    int32_t NodeOfs[_NT_MaxItems];
} TFileHead;
typedef const TFileHead FAR *LPCTFileHead;

typedef struct tagTFileNodeInfo // 文件数据节定义
{
    int32_t num;  // 单元数
    int32_t size; // 单元长
    int32_t len;  // 单元数据长
} TFileNodeInfo;
typedef const TFileNodeInfo FAR *LPCTFileNodeInfo;

typedef struct tagTIPara103 // 积分参数(0x103及其早期版本)
{
    float pkWidth;        // 最小峰宽(min)
    int32_t pkNoise;      // 噪声阈值(uV)
    float initTime;       // 起始积分时间(min.)
    float stopTime;       // 自动停止时间(min.)
    int32_t minArea;      // 最小峰面积
    int32_t minHeight;    // 最小峰高
    int32_t autoNegative; // 是否自动检测负峰
    int32_t shouldSens;   // 是否肩峰敏感
    int32_t tprgUsed;     // 是否使用时间表
    int32_t width;        // 滤波宽度(p) [用于算法内部,界面上不必体现]
    float slope;          // 噪声阈值(uV)  [用于算法内部,界面上不必体现]
} TIPara103;
typedef const TIPara103 FAR *LPCTIPara103;

// size = 108
typedef struct tagTIPara // 积分参数
{
    float pkWidth;        // 最小峰宽(min) x0 => 0
    int32_t pkNoise;      // 噪声阈值(uV) x1 => 4
    float pkDrift;        // 漂移(uV/sec) x2 => 8
    float testPkWidth;    // 自动测试出的峰宽值(min)  x3 => 12
    int32_t testPkNoise;  // 自动测试出的噪声值(uV)  x4 => 16
    float testPkDrift;    // 自动测试出的漂移值(uV/min)  x5 => 20
    float initTime;       // 起始积分时间(min)  x6 => 24
    float stopTime;       // 自动停止时间(min)  x7 => 28
    int32_t minArea;      // 最小峰面积(uV.s)  x8 => 32
    int32_t minHeight;    // 最小峰高(uV)  x9 => 36
    PKWD_MODE wdMode;     // 变宽模式 x10 => 40
    float tdouble;        // 倍宽时间(min) x11 => 44
    TAIL_MODE tailMode;   // 拖尾峰检测模式 x12 => 48
    int32_t autoNegative; // 是否自动检测负峰 x13 => 52
    int32_t shouldSens;   // 是否肩峰敏感 x14 => 56
    int32_t tprgUsed;     // 是否使用时间表 x15 => 60
    int32_t width;        // 滤波宽度(count) [用于算法内部,界面上不必体现] x16 => 64
    float slope;          // 斜率(uV/count)  [用于算法内部,界面上不必体现] x17 => 68
    float drift;          // 漂移(uV/count)  [用于算法内部,界面上不必体现] x18 => 72
    char nop[32];         // x19 => 76
} TIPara;
typedef const TIPara FAR *LPCTIPara;

// 时间程序
typedef union tagTPRGPARA
{
    float f;
    int32_t n;
    int32_t b;
} TPRGPARA;

typedef struct tagTDLLTPRGListItem // 手动事件表
{
    float ts;           // 起始时间(min.)
    float te;           // 结束时间(min.)
    EVENT event;        // 时间事件
    TPRGPARA paraValue; // 参数值
} TDLLTPRGListItem;
typedef const TDLLTPRGListItem FAR *LPCTDLLTPRGListItem;

typedef struct tagTTprgItem
{
    TDLLTPRGListItem DLLPRGItem; // DLL手动事件表
    int32_t enable;              // 是否有效
} TTprgItem;
typedef const TTprgItem FAR *LPCTTprgItem;

// 时间表描述
typedef struct tagTDLLTPRGINF
{
    TDLLTPRGListItem *head;
    int32_t len;
    LPINT num;
} TDLLTPRGINF;

typedef struct tagTDLLGROUPListItem // 分组表
{
    double Area;           // 组累计峰面积 x0 -> 0
    double Height;         // 组累计峰高 x2 -> 8
    double AreaPer;        // 组累计面积% x4 -> 16
    double Conc;           // 组累计含量 x6 -> 24
    float TrLower;         // 保留时间上限(min.) x8 -> 32
    float TrUpper;         // 保留时间上限(min.) x9 -> 36
    char Name[NameLength]; // 组名 x10 -> 40
} TDLLGROUPListItem;
typedef const TDLLGROUPListItem FAR *LPCTDLLGROUPListItem;

typedef struct tagTDLLGROUPListItemMerged
{
    char Name[NameLength];
    double Area;
    double Height;
    double AreaPer;
    double Conc;
} TDLLGROUPListItemMerged;

typedef struct tagTGroupItem // 分组表(扩充)
{
    char Name[NameLength];         // 组名
    char IdNames[NameLength * 32]; // 组分名表
    char RefIdName[NameLength];    // 参考组分
    int32_t Continuous;            // 是否连续组
    int32_t NeedRefId;             // 是否需要参考组分(酒版专用)
    float tLower;                  // 时间下限(min.)
    float tUpper;                  // 时间上限(min.)
    float cLower;                  // 品控下限
    float cUpper;                  // 品控上限
    // int32_t     Reserve[8];           //保留字段  //HPG   //2014-12-xx: xxxxxx    //改为:
    float dLimit;           // 检出限
    int32_t ConcUnitFactor; // 浓度单位因子值(0-使用配样信息中指定的含量单位, 2+UNIT_N:%, 3+UNIT_N:‰, 6+UNIT_N:ppm,
                            // 9+UNIT_N:ppb, 12+UNIT_N:ppt)
    union
    {
        int32_t Reserve[6]; // 保留字段
        struct
        {
            int32_t HPGOperator;     // 高纯气专用版限值算符
            float HPGLimitValues[3]; // 高纯气专用版限值
        };
    };

} TGroupItem; // sizeof=1144=143*8
typedef const TGroupItem FAR *LPCTGroupItem;

typedef struct tagTGroupItem111 // 分组表(0x111或以前的版本)
{
    char IdtName[NameLength]; // 组分名
    char Name[NameLength];    // 组名
    float TrLower;            // 保留时间下限(min.)
    float TrUpper;            // 保留时间上限(min.)
} TGroupItem111;
typedef const TGroupItem111 FAR *LPCTGroupItem111;

typedef struct tagTGroupItemJiu // 酒版专用分组表
{
    char Name[NameLength];         // 组名
    char IdNames[NameLength * 32]; // 组分名表
    char RefIdName[NameLength];    // 参考组分
    int32_t P60;                   // 是否进行60℃酒换算
    double Conc;                   // 组含量
} TGroupItemJiu;
typedef const TGroupItemJiu FAR *LPCTGroupItemJiu;

// 分组表描述
typedef struct tagTDLLGRPINF
{
    TDLLGROUPListItem *head; // 分组表缓区头指针
    int32_t len;             // 缓区长
    LPINT num;
} TDLLGRPINF;

//  组份表及其描述 -----------------------------------

typedef struct tagTDLLIDTListItem_1407 // 1407及之前版本的组份表 (y= f3*x^3 + f2*x^2 + f1*x +f0)
{
    union
    {
        struct // Easy3000:
        {
            double f0_Easy3000; // x0 -> 0
            double f1_Easy3000; // x2 -> 8
            double f2_Easy3000; // x4 -> 16
            double f3_Easy3000; // x6 -> 24
            union
            {
                double r_x104; // 0x104版本的相关系数 x8 -> 32
                struct         // 0x106:
                {
                    float r_x106; // 最小二乘法求取校正因子的相关系数 x8 -> 32
                    float k_x106; // 扩充系数(发热系数, 分子量等) x9 -> 36
                };
            };
        };
        struct // Easy3010:
        {
            float f0; // 校正因子常数项 x0 -> 0
            float f1; // 校正因子一次项 x1 -> 4
            float f2; // 校正因子二次项 x2 -> 8
            float f3; // 校正因子三次项 x3 -> 12
            union
            {
                float MolW; // 分子量 x4 -> 16
                float CalK; // 发热系数 x4 -> 16
                float k;    // 扩充系数k x4 -> 16
                int32_t nK; // 扩充系数nK x4 -> 16
            };
            union
            {
                float dLimit; // 检出限(detection limit) x5 -> 20
                float k1;     // 扩充系数k1 x5 -> 20
                int32_t nK1;  // 扩充系数nK1 x5 -> 20
            };
            float cLower;    // 品控下限 x6 -> 24
            float cUpper;    // 品控上限 x7 -> 28
            float r;         // 最小二乘法求取校正因子的相关系数 x8 -> 32
            int32_t basedOn; // 定量基准(0-面积, 1-峰高) x9 -> 36
        };
    };
    double weight;         // 组份重量 x10 -> 40
    char Name[NameLength]; // 组份名 x12 -> 48
    float Time;            // 保留时间(min.) x20 -> 80
    float band;            // 带宽(min.) x21 -> 84
    /*
    int32_t     istdNoSelf; //拟引入的内标物号
    int32_t     istdNoUsed; //被标定的内标物号
    */
    // 2012-05-xx: xxxxxx

    short istdNoSelf; // 拟引入的内标物号 x22 -> 88
    short TypeEx;
    short istdNoUsed; // 被标定的内标物号 x23 -> 92
    short Reserve;
} TDLLIDTListItem_1407;
typedef const TDLLIDTListItem_1407 FAR *LPCTDLLIDTListItem_1407;

#define _MaxSegCalib_ 16        // 分段校正的最段数
typedef struct tagTSegCalibItem // 分段校正数据项
{
    double x; // 校正段X值上限
    double a; // 校正段直线斜率
    double b; // 校正段直线截距
} TSegCalibItem;
typedef struct tagTDLLIDTListItem_1408Ex // 1408及之后版本的组份表新增内容(size = 512)
{
    int32_t SegCalibMode;                       // 分段校正模式 (0-不分段, 1-低位过零, 2-点点连线) x0 -> 0
    int32_t SegCalibCount;                      // 校正段数 x1 -> 4
    TSegCalibItem SegCalibItems[_MaxSegCalib_]; // 分段校正数据 x2 -> 8
    BYTE Reserves[120];                         // x98 -> 392
} TDLLIDTListItem_1408Ex;

typedef struct tagTDLLIDTListItem // 1408及之后的组份表 (y= f3*x^3 + f2*x^2 + f1*x +f0)
{
    union
    {
        struct // Easy3000:
        {
            double f0_Easy3000; // x0 -> 0
            double f1_Easy3000; // x2 -> 8
            double f2_Easy3000; // x4 -> 16
            double f3_Easy3000; // x6 -> 24
            union
            {
                double r_x104; // 0x104版本的相关系数 x8 -> 32
                struct         // 0x106:
                {
                    float r_x106; // 最小二乘法求取校正因子的相关系数 x8 -> 32
                    float k_x106; // 扩充系数(发热系数, 分子量等) x9 -> 36
                };
            };
        };
        struct // Easy3010:
        {
            float f0; // 校正因子常数项 x0 -> 0
            float f1; // 校正因子一次项 x1 -> 4
            float f2; // 校正因子二次项 x2 -> 8
            float f3; // 校正因子三次项 x3 -> 12
            union
            {
                float MolW; // 分子量 x4 -> 16
                float CalK; // 发热系数 x4 -> 16
                float k;    // 扩充系数k x4 -> 16
                int32_t nK; // 扩充系数nK x4 -> 16
            };
            union
            {
                float dLimit; // 检出限(detection limit) x5 -> 20
                float k1;     // 扩充系数k1 x5 -> 20
                int32_t nK1;  // 扩充系数nK1 x5 -> 20
            };
            float cLower;    // 品控下限 x6 -> 24
            float cUpper;    // 品控上限 x7 -> 28
            float r;         // 最小二乘法求取校正因子的相关系数 x8 -> 32
            int32_t basedOn; // 定量基准(0-面积, 1-峰高) x9 -> 36
        };
    };
    double weight;         // 组份重量 x10 -> 40
    char Name[NameLength]; // 组份名 x12 -> 48
    float Time;            // 保留时间(min.) x20 -> 80
    float band;            // 带宽(min.) x21 -> 84
    /*
    int32_t     istdNoSelf; //拟引入的内标物号
    int32_t     istdNoUsed; //被标定的内标物号
    */
    // 2012-05-xx: xxxxxx

    short istdNoSelf; // 拟引入的内标物号 x22 -> 88
    short TypeEx;
    short istdNoUsed; // 被标定的内标物号 x23 -> 92
    short Reserve;

    // 1408及之后版本的组份表新增内容(size = 512):
    union
    {
        TDLLIDTListItem_1408Ex _1408Ex; //  x24 -> 96
        struct
        {
            int32_t SegCalibMode;                       // 分段校正模式 (0-不分段, 1-低位过零, 2-点点连线) 24 -> 96
            int32_t SegCalibCount;                      // 校正段数 x25 -> 100
            TSegCalibItem SegCalibItems[_MaxSegCalib_]; // 分段校正数据 x26 -> 104
            // BYTE  Reserves[120];  //HPG   //2014-12-xx: xxxxxx    //改为: x122 -> 488
            int32_t ConcUnitFactor;                                       // 浓度单位因子值(0-使用配样信息中指定的含量单位, 2+UNIT_N:%, 3+UNIT_N:‰,
                                                                          // 6+UNIT_N:ppm, 9+UNIT_N:ppb, 12+UNIT_N:ppt)
            int32_t Reserve_;                                             //(保留) x123 -> 492
            int32_t HPGOperator;                                          // 高纯气专用版限值算符 x124 -> 496
            float HPGLimitValues[3];                                      // 高纯气专用版限值 x125 -> 500
            float RefRTime;                                               // 参考保留时间 x128->512
            BYTE Reserves[120 - 3 * sizeof(int32_t) - 4 * sizeof(float)]; // x129 -> 516
        };
    };

} TDLLIDTListItem;
typedef const TDLLIDTListItem FAR *LPCTDLLIDTListItem;

// 组份表描述
typedef struct tagTDLLIDTINF
{
    TDLLIDTListItem *head; // 组份表缓区头指针
    int32_t len;           // 缓区长
    LPINT num;
} TDLLIDTINF;
typedef const TDLLIDTINF FAR *LPCTDLLIDTINF;

typedef struct tagTEPara // 计算参数
{
    BASEDON based;   // 定量基准
    QUANTBY quantBy; // 定量方法
    int32_t grouped; // 是否分组
} TEPara;
typedef const TEPara FAR *LPCTEPara;

typedef struct tagTIntegralMethodHead_x103 // 0x103及其早期版本
{
    int32_t ModifyTime;
    int32_t AutoWidth;
    int32_t AutoNoise;
    float pkWidth;
    int32_t pkNoise;
    TIPara103 IPara103; // 0x103及其早期版本
    TEPara EPara;
    int32_t SmpCatID;
    int32_t Public;
} TIntegralMethodHead_x103;
typedef const TIntegralMethodHead_x103 FAR *LPCTIntegralMethodHead_x103;

typedef struct tagTIntegralMethodHead_x104
{
    char mark[8]; // 版本标识
    int32_t ModifyTime;
    int32_t AutoWidth;
    int32_t AutoNoise;
    int32_t AutoDrift;
    float pkWidth;   // 峰宽[min]
    int32_t pkNoise; // 噪声[uV]
    float pkDrift;   // 漂移[uV/sec]
    TIPara IPara;
    TEPara EPara;
    float sliceUsed;   // 是否计算切片结果
    float sliceWidth;  // 切片宽[min]
    int32_t sliceZero; // 切片零点[uV]
    int32_t SmpCatID;
    int32_t Public;
    TUNITCODE pkWidthUnitCode; // 峰宽单位代码(0-min,1-秒)
    TUNITCODE sliceUnitCode;   // 切片宽单位代码(0-min,1-秒)
    char nop[12];
} TIntegralMethodHead_x104;
typedef const TIntegralMethodHead_x104 FAR *LPCTIntegralMethodHead_x104;

typedef struct tagTUkPkFactor
{
    int32_t type; // 0--计零, 1--手工输入, x--组分索引+2
    float f0;
    float f1;
    float f2;
    float f3;
    float cLower; // 品控下限
    float cUpper; // 品控上限
} TUkPkFactor;    // sizeof=28=7*4

struct TMiscellaneous // analysis.dll中杂项参数
{
    int32_t QualitMode;     // 定量模式 [0-时间带, 1-时间窗, 2-顺序法] // x0 -> 0
    int32_t RefEnabled;     // 参考峰启用标志 // x1 -> 4
    int32_t IstdAsRef;      // 内标组分是否视作为参考峰 // x2 -> 8
    int32_t Reserve;        //(保留) // x3 -> 12
    double IdtWindow;       // 组分表时间窗[%] // x4 -> 16
    double IdtTimeOfs;      // 进样偏移时间[min] // x6 -> 24
    TUkPkFactor UkPkFactor; // 未知峰校正因子 // x8 -> 32
    double XMinUnitK;       // X轴标注单位(默认min)到最小标注单位(算面积用,默认sec)的换算系数(XMinUnit=XMinUnitK*XUnit,
                            // 默认=60) //x15,16 -> 60
    double YMinUnit;        // 信号值最小度量单位(uV)到采集器最小度量单位(1uV)的转换系数(默认值=1) //x17,8 -> 68
};

typedef struct tagTIntegralMethodHead_x112
{
    char mark[8]; // 版本标识
    int32_t ModifyTime;
    int32_t AutoWidth;
    int32_t AutoNoise;
    int32_t AutoDrift;
    float pkWidth;   // 峰宽[min]
    int32_t pkNoise; // 噪声[uV]
    float pkDrift;   // 漂移[uV/sec]
    TIPara IPara;
    TEPara EPara;
    float sliceUsed;   // 是否计算切片结果
    float sliceWidth;  // 切片宽[min]
    int32_t sliceZero; // 切片零点[uV]
    int32_t SmpCatID;
    int32_t Public;
    TUNITCODE pkWidthUnitCode;  // 峰宽单位代码(0-min,1-秒)
    TUNITCODE sliceUnitCode;    // 切片宽单位代码(0-min,1-秒)
    char CalibName[NameLength]; // 使用的校正表名
    int32_t ManualCalib;        // 是否手工输入校正因子
    float YUnit;
    char YLabel[32];
    TUkPkFactor UkPkFactor; // 未知峰校正因子
    // char    nop[8];
} TIntegralMethodHead_x112;
typedef const TIntegralMethodHead_x112 FAR *LPCTIntegralMethodHead_x112;

typedef struct tagTCalorifParam
{
    int32_t CalorifValid; // 有效标志
    int32_t GSClass;      // 燃气类别(0-工业煤气, 1-人工煤气, 2-天然气, 3-液化石油气)
    int32_t CaloUnitIdx;  //(热值版)体积热值单位索引(0-kC/m^3, 1-kJ/m^3, 2-MJ/m^3)
    int32_t CaloBasedOn;  //(热值版)热值数据基准(0-使用低位, 1-使用高位)
    double t1;            // 燃烧温度(0, 15, 20, 25℃)
    double t2;            // 计量温度(0, 15, 20℃)
    double p1;            // 燃烧压力(=101.325kPa)
    double p2;            // 计量压力(=101.325kPa)
} TCalorifParam;

// OAIG  //2014-02-20: ++++++
typedef struct tagTGasoSHTParam
{
    int32_t GasoSHTValid; // 有效性标志
    int32_t GasoSHTID;    // 汽油中组成分析方法ID(0-未知, 1-SHT0663醇醚测定, 2-SHT0693芳烃测定)
} TGasoSHTParam;

// HPG   //2014-12-xx: ++++++
typedef struct tagTHPGParam
{
    int32_t HPGValid; // 有效性标志
    int32_t HPGType;  // 高纯气类别(0-未知, 1-高纯氧, 2-高纯氢, 3-高纯氩, 4-高纯氮, 5-高纯氦, 6-高纯CO2)
} THPGParam;

typedef struct tagTIntegralMethodHead
{
    char mark[8]; // 版本标识
    int32_t ModifyTime;
    int32_t AutoWidth;
    int32_t AutoNoise;
    int32_t AutoDrift;
    float pkWidth;   // 峰宽[min]
    int32_t pkNoise; // 噪声[uV]
    float pkDrift;   // 漂移[uV/sec]
    TIPara IPara;
    TEPara EPara;
    float sliceUsed;   // 是否计算切片结果
    float sliceWidth;  // 切片宽[min]
    int32_t sliceZero; // 切片零点[uV]
    int32_t SmpCatID;
    int32_t Public;
    TUNITCODE pkWidthUnitCode;  // 峰宽单位代码(0-min,1-sec)
    TUNITCODE sliceUnitCode;    // 切片宽单位代码(0-min,1-sec)
    char CalibName[NameLength]; // 使用的校正表名
    int32_t ManualCalib;        // 是否手工输入校正因子
    union
    {
        float YUnit;
        float x114_YMinUnit; // x114版本的定义
    };
    union
    {
        char YLabel[NameLength];
        char x114_YMinLabel[NameLength]; // x114版本的定义
    };
    TUkPkFactor UkPkFactor; // 未知峰校正因子 (至此,size=284bytes)

    // 以下为x113及后续版本的扩充字段:
    union
    {
        char nop[4]; // 补白   (至此,size=288bytes=32*9)

        struct // 标定后的纯量单位编码:
        {
            WORD CalibAmtUnitType; // 类别 (0-未知, 1-无单位, 2-mg, 3-uL, 4-mmol)
            WORD CalibAmtExCode;   // 扩充码 (NMHC时，用于指明计量基准: 0-未知, 1-以碳计, 2-以甲烷计)
        };
    };
    float cLowerOfSum; // 合计品控下限
    float cUpperOfSum; // 合计品控上限
    char Notes[128];
    union
    {
        char Reserve_x114[600]; // 0x114版本的定义
        struct
        {
            // 0x115版本的定义:
            double XMinUnitK;        // X轴标注单位到最小标注单位的换算系数(XMinUnit=XMinUnitK*XUnit, 默认值=60)
            char XLabel[NameLength]; // X轴的标注单位(默认值=min)
            char XMinLabel[24];      // X轴的最小标注单位(默认值=sec)
            int32_t SuperType;       // 谱图数据类别(0-色谱数据, 1-紫外/可见光谱数据, ...)

            // 0x116版本的定义: (2010-06-05)
            int32_t IdtQualitMode; // 定性模式(0-时间带, 1-时间窗, 2-顺序法)
            float IdtTimeWindow;   // 时间窗[%]

            int32_t Reserve_;

            union
            {
                struct
                {
                    int32_t CalorifValid; // 有效标志
                    int32_t GSClass;      // 燃气类别(0-人工煤气, 1-天然气, 2-液化石油气, 3-其它)
                    int32_t CaloUnitIdx;  //(热值版)体积热值单位索引(0-kC/m^3, 1-kJ/m^3, 2-MJ/m^3)
                    int32_t CaloBasedOn;  //(热值版)热值数据基准(0-使用低位, 1-使用高位)
                    double t1;            // 燃烧温度(0, 15, 20, 25℃)
                    double t2;            // 计量温度(0, 15, 20℃)
                    double p1;            // 燃烧压力(=101.325kPa)
                    double p2;            // 计量压力(=101.325kPa)
                };
                TCalorifParam CalorifParam;
            };

            // OAIG  //2014-02-20: ++++++
            union
            {
                struct
                {
                    int32_t GasoSHTValid; // 有效标志
                    int32_t GasoSHTID;    // 汽油中组成分析方法ID(0-未知, 1-SHT0663醇醚测定, 2-SHT0693芳烃测定)
                };
                TGasoSHTParam GasoSHTParam;
            };

            // HPG   //2014-12-xx: ++++++
            union
            {
                struct
                {
                    int32_t HPGValid; // 有效标志
                    int32_t HPGType;  // 高纯气类别(0-未知, 1-高纯氧, 2-高纯氢, 3-高纯氩, 4-高纯氮, 5-高纯氦, 6-高纯CO2)
                };
                THPGParam HPGParam;
            };
            int32_t AutoFixRTimeType;
        };
    };
} TIntegralMethodHead; // size=1024bytes=1K
typedef const TIntegralMethodHead FAR *LPCTIntegralMethodHead;

typedef struct tagAUTOIPARA103 // 自动参数(0x103及其早期版本)
{
    int32_t width; // 最小峰宽(min)
    float noise;   // 噪声阈值(uV)
} AUTOIPARA103;
typedef const AUTOIPARA103 FAR *LPCAUTOIPARA103;

typedef struct tagAUTOPARA103 // 自动参数(0x103及其早期版本)
{
    float pkWidth;   // 最小峰宽(min)
    int32_t pkNoise; // 噪声阈值(uV)
} AUTOPARA103;
typedef const AUTOPARA103 FAR *LPCAUTOPARA103;

typedef struct tagAUTOIPARA // 自动参数
{
    int32_t width; // 最小峰宽(min)
    float noise;   // 噪声阈值(uV)
    float drift;   // 基线漂移(uV/count)
} AUTOIPARA;
typedef const AUTOIPARA FAR *LPCAUTOIPARA;

typedef struct tagAUTOPARA // 自动参数
{
    float pkWidth;   // 最小峰宽(min)
    int32_t pkNoise; // 噪声阈值(uV)
    float pkDrift;   // 基线漂移(uV/sec)
} AUTOPARA;
typedef const AUTOPARA FAR *LPCAUTOPARA;

typedef struct tagTStdSmpInj
{
    int32_t nos;        // 校正点序
    char szFile[512];   // 标样谱图文件名
    int32_t repNum;     // 平行样重复次数//同一标样号中拟选定的平行进样数目
    int32_t repInj[16]; // 平行样进样序号//同一标样号中拟选定的平行进样序号列表（最多16个）
} TStdSmpInj;
typedef const TStdSmpInj FAR *LPCTStdSmpInj;

typedef struct tagTStdConcResp
{
    int32_t idNo;        // 组分号
    int32_t nos;         // 校正点序
    double conc;         // 组分浓度
    double wt;           // 组分纯量
    double avgArea;      // 组分平均面积
    double repArea[16];  // 组分各平行样面积
    double sdArea;       // 组分面积标准偏差
    double rsdArea[16];  // 组分面积相对标准偏差
    float avgHeight;     // 组分平均峰高
    float repHeight[16]; //    组分各平行样峰高
    float sdHeight;      //    组分峰高标准偏差
    float rsdHeight[16]; //    组分峰高相对标准偏差
    float r;
} TStdConcResp;
typedef const TStdConcResp FAR *LPCTStdConcResp;

// 标样用量表
typedef struct tagTSTDAMTListItem
{
    TDLLMETRIC metric; // 标样用量
    int32_t repNum;    // 重复进样次数 (每个标样的重复进样次数可能不同)
    int32_t reserved;
} TSTDAMTListItem;
typedef const TSTDAMTListItem FAR *LPCTSTDAMTListItem;

// 标样用量表描述
typedef struct tagTAMTINF
{
    TSTDAMTListItem *head; // 组份用量表缓区头指针
    int32_t len;           // 缓区长(即允许最多的校正点数)
    LPINT num;             // 缓区项目数(即校正点数)指针 int32_t *
} TAMTINF;
typedef const TAMTINF FAR *LPCTAMTINF;

// 标样组份浓度表
typedef struct tagTSTDCPTListItem // 以下项目依次按点序、重复次序、组份号的顺序连续排列
{
    double weight; // 各组份浓度
    double area;   // 各组份峰面积
    float height;  // 各组份峰高
    int32_t Reserved;
} TSTDCPTListItem;
typedef const TSTDCPTListItem FAR *LPCTSTDCPTListItem;

// 标样组份浓度表描述
typedef struct tagTCPTINF
{
    TSTDCPTListItem *head; // 组份浓度表缓区头指针
    int32_t len;           // 缓区长
    LPINT num;             // 缓区项目数(校正点数*组份数)指针 int32_t *
} TCPTINF;
typedef const TCPTINF FAR *LPCTCPTINF;

// 标样表描述
typedef struct tagTDLLSTDINF
{
    int32_t CurveType; // 校正次数  0 直线 1 二次 2 三次
    int32_t Zero;      // 过零  0 1 2
    TAMTINF *amtInf;   // 标样用量表描述
    TCPTINF *cptInf;   // 标样组份浓度表描述
} TDLLSTDINF;
typedef const TDLLSTDINF FAR *LPCTDLLSTDINF;

/*typedef struct tagTCalibPara{
    char MethodName[NameLength];
    int32_t CurveType;
    int32_t ZeroType;
    char notes[NoteLength];
    char nop[NoteLength];
}TCalibPara;*/
typedef struct tagTCalibPara
{
    char MethodName[NameLength];
    int32_t CurveType;
    int32_t ZeroType;
    char notes[NoteLength];
    char YMinLabel[NameLength];
    // char nop[NoteLength-NameLength];  //2013-09-07: xxxxxx
    // char nop[NoteLength];
    // char nop[NoteLength-NameLength];  //2013-04-xx: xxxxxx    //改为:
    union
    {
        BYTE Reserves[NoteLength - NameLength];
        struct // 标定后的纯量单位编码:
        {
            WORD AmtUnitType; // 类别 (0-未知, 1-无单位, 2-mg, 3-uL, 4-mmol)
            WORD AmtExCode;   // 扩充码 (NMHC时，用于指明计量基准: 0-未知, 1-以碳计, 2-以甲烷计)

            // HCIG  //2013-09-07: ++++++
            double RelSFactDivisor; // 修正归一法时换算为相对校正因子的除数(0表示未换算)
        };
    };
} TCalibPara;
typedef const TCalibPara FAR *LPCTCalibPara;

typedef struct tagTCalibHead
{
    TCalibPara CalibPara;
    int32_t ModifyTime;
    char StdClassName[NameLength];
    int32_t AmplifyFactor;
    int32_t PageIndex;
} TCalibHead;
typedef const TCalibHead FAR *LPCTCalibHead;

typedef struct tagTCalibFactor
{
    double f0;
    double f1;
    double f2;
    double f3;
    double r;
} TCalibFactor;

typedef struct tagTChannelHead // 通道信息
{
    char ChannelName[16]; // 通道名
    char UserName[32];    // 用户名
    char InstName[32];    // 仪器名
    int32_t SignalNo;     // 仪器信号通路序号
    int32_t nReserve;     //(保留字段)
} TChannelHead;

// 关于仪器 ------------------------------------------------------
typedef struct tagTInstHead_0x113 // 仪器信息结构
{
    int32_t ID;
    int32_t Type;
    int32_t ProgramLevel;
    char Model[ModelLength];
    char MarkNo[ModelLength];
    char Manufacturer[SpecLength];
    int32_t PumpType;
    char PumpModel[ModelLength];
    char PumpFlowRateSpec[SpecLength];
    char PumpPressureSpec[SpecLength];
    char Notes[NoteLength];
    double ModifyTime;
    char Name[64];
    char nop[64];
} TInstHead_0x113;

typedef struct tagTInstSigConn_0x113 // 检测器通路结构
{
    int32_t ID;                        // 通路ID
    int32_t InstID;                    // 仪器ID
    int32_t SignalNo;                  // 信号通路序号
    int32_t DetectType;                // 检测器类型
    int32_t InletType;                 // 进样器类型
    int32_t ColumnType;                // 色谱柱类型
    char DetectModel[ModelLength];     // 检测器型号
    char InjectModel[ModelLength];     // 进样器型号
    char ColumnModel[LongModelLength]; // 色谱柱型号
    char DetectName[20];               // 检测器名
    char InletName[20];                // 进样口名
    char ColumnName[20];               // 色谱柱名
    char DetectSpec[20];               // 检测器说明
    char InletSpec[20];                // 进样口说明
    int32_t AutoInjector;              // 是否自动进样
} TInstSigConn_0x113;

typedef struct tagTInstSig_0x113 // 仪器通路结构
{
    int32_t InstID;
    int32_t SignalNo;
    int32_t InstType;
    int32_t DetectType;
    int32_t InletType;
    int32_t ColumnType;
    int32_t AutoInjector;
} TInstSig_0x113;

//------------------------------------------------------
typedef struct tagTInstHead // 仪器头信息
{
    union
    {
        BYTE Bytes[256];
        struct
        {
            int32_t ID;            // ID
            int32_t Type;          // 仪器类别(GC, LC, IC, CE-毛细管电泳)
            char TypeAbbr[8];      // 类别缩写
            char TypeName[48];     // 类别名
            char Model[32];        // 型号
            char MarkNo[32];       // 设备号
            char Manufacturer[48]; // 制造商
            // BYTE    Reserve[80];    //(保留字段)
        };
    };
} TInstHead; // size=256

typedef struct tagTOvenInfo // 柱温箱信息
{
    union
    {
        BYTE Bytes[128];
        struct
        {
            int32_t Available;    // 是否有效
            int32_t MaxTempRamps; // 最大程升阶数
            double MaxTemp;       // 最高温度[K]
            double Equilibry;     // 平衡时间[min]
            double dReserve;      //(保留字段)
            char Model[32];       // 型号
            // BYTE  Reserve[64];    //(保留字段)
        };
    };
} TOvenInfo; // size=128

typedef struct tagTPumpInfo // 泵信息
{
    union
    {
        BYTE Bytes[128];
        struct
        {
            int32_t Available;    // 是否有效
            int32_t Type;         // 类别(恒流, 二元梯度, 三元梯度, 四元梯度)
            int32_t GradPresMode; // 梯度压力模式(低压, 高压)
            int32_t nReserve;     //(保留字段)
            double MaxPressure;   // 最高压力[psi]
            double MinPressure;   // 最低压力[psi]
            char Model[32];       // 型号
            // BYTE  Reserve[64];    //(保留字段)
        };
    };
} TPumpInfo; // size=128

typedef struct tagTInletInfo // 进样口信息
{
    union
    {
        BYTE Bytes[128];
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别(PIP-Packed Injection Port, SSL-Capillary Split/Splitless Inlet,
            // COC-Cool On-Column, PTV-Programmable Temperature Vaporization,
            // Volatiles Interface,
            // Rheodyne 7725系列, Rheodyne 9725系列, Rheodyne 3725-038系列)
            char TypeAbbr[8];     // 类别缩写
            char TypeName[32];    // 类别名
            int32_t InjMode;      // 进样方式(Manual, GSV-气体进样阀, Auto Sampler)
            int32_t ASType;       // 自动进样器分类码(暂不使用)
            double InjVolume;     // 定量管体积[uL]
            char InjectModel[32]; // 进样器型号         //2010-11-23: &&&&&&
            // BYTE    Reserve[32];
        };
    };
} TInletInfo; // size=128

typedef struct tagTColumnInfo // 色谱柱信息
{
    union
    {
        BYTE Bytes[128];
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别(Packed, Capillary, Wide-Bore Capillary, HPLC Column,
            // GPC Column, IC Column, Unknown)
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            int32_t FreqIdx;   // 采样频率索引号(0-高速,1-快速,2-中速,3-慢速,4-低速)
            int32_t mmLength;  // 柱长[mm]
            double Diameter;   // 内径[mm]
            double FilmThick;  // 膜后[μm]
            double DeadTime;   // 死时间[min]
            char Model[32];    // 型号
            // BYTE  Reserve[16];    //(保留字段)
        };
    };
} TColumnInfo; // size=128

typedef struct tagTDetectInfo // 检测器信息
{
    union
    {
        BYTE Bytes[256];
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别(FID, TCD, ECD, NPD, FPD, PID, HID-氦离子化检测器, MSD
            // UVD, RID, DAD, FD, ECD-电化学, CD-电导, ELSD-蒸发光散射)
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            char Model[32];    // 型号
            double RangeMax;   // 响应最大值
            double RangeMin;   // 响应最小值
            double RangeValue; // 检测量程[满偏检测量]
            // double  dReserve;       //(保留字段)          //2011-03-23: xxxxxx
            double Sensitivity;    // 检测灵敏度(以量程单位表示的检测量/lsb)    //2011-03-23: ++++++
            char DeteUnit[16];     // 检测单位                  //2011-03-23: &&&&&&
            char RangeOptions[96]; // 量程选项表
            // BYTE  Reserve[32];    //(保留字段)
        };
    };
} TDetectInfo; // size=256

typedef struct tagTAuxiliaryInfo // 辅助区信息
{
    union
    {
        BYTE Bytes[128];
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 部件类别
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            char Model[32];    // 型号
            // BYTE  Reserve[56];    //(保留字段)

            int32_t SensType; // 传感类别(0-温度, 1-压力, 2-流量)
            int32_t OnOff;    // 开关状态          //2011-10-08: ++++++
            int32_t PosNo;    // 位置号(从1算起) //2011-09-20: ++++++
        };
    };
} TAuxiliaryInfo; // size=128

typedef struct tagTSignalInfo // 信号通路
{
    union
    {
        BYTE Bytes[64];
        struct
        {
            int32_t Available;   // 是否有效
            int32_t OvenNo;      // 柱箱序号(索引号+1)
            int32_t InletNo;     // 进样口序号(索引号+1)
            int32_t ColumnNo;    // 柱序号(索引号+1)
            int32_t DetectNo;    // 检测器序号(索引号+1)
            int32_t AuxiliaryNo; // 辅助区序号(索引号+1)
            int32_t ExCol1No;    // 扩充柱1序号
            int32_t ExCol2No;    // 扩充柱2序号

            union
            {
                int32_t ExDet1No; // 扩充检测器1序号
                int32_t PathID;   // 通道ID
            };

            int32_t ExDet2No; // 扩充检测器2序号
            int32_t ExAux1No; // 扩充辅助区1序号
            int32_t ExAux2No; // 扩充辅助区2序号
            BYTE Reserve[16]; //(保留字段)
        };
    };
} TSignalInfo; // size=64

// TInstCond: ===================================================================
typedef struct tagTInstCondHead_0x113 // 仪器条件结构
{
    int32_t ID;
    int32_t SignalNo;
    int32_t InstID;
    int32_t SmpCatID;
    char Name[NameLength];
    char DetectCond[CondLength];
    char InletCond[CondLength];
    char ColumnCond[CondLength];
    float ColumnLen; // 柱长[m]
    char PumpCond[CondLength];
    char MobileCond[LongCondLength];
    int32_t ByProgram;
    int32_t ByGradient;
    char Notes[NoteLength];
    double ModifyTime;

    // char    nop[NoteLength];
    float DeadTime; // 死时间[min]
    char nop[NoteLength - sizeof(float)];
} TInstCondHead_0x113;

typedef struct tagTInstCondHead // 仪器条件头信息
{
    // static Info:  //size=256
    union
    {
        TInstHead InstInfo;
        struct
        {
            int32_t InstID;       // ID
            int32_t InstType;     // 仪器类别(GC, LC, IC, CE-毛细管电泳)
            char InstTypeAbbr[8]; // 类别缩写
            union
            {
                char InstTypeName[48];   // 类别名
                char SeparationType[48]; // 分离方法：
                // GC - Gas Chromatography
                //  Gas Liquid Chromatography (气-液)
                //  Gas Solid Chromatography (气-固)
                // LC - Liquid Chromatograhy
                //  Normal Phase Liquid Chromatograhy (正相),
                //  Reversed Phase Liquid Chromatograhy (反相)
                //  Gel Permeation Chromatograhy (凝胶渗透色谱)
                //  Size Exclusion Liquid Chromatograhy(体积排阻色谱SEC)
                // IC - Ion Chromatograhy
                //  Ion Exchange Liquid Chromatograhy (离子交换)
                //  Ion Pair Liquid Chromatograhy (离子对)
                // CE    - Capillary Zone Electrophoresis (毛细管电泳)
                // SFC - Supercritical Fluid Chromatograhy (超临界流体色谱)
                // TLC - Thin Layer Chromatograhy (薄层色谱)
                // FFF - Field Flow Fractionation (场流分离)
                // Other Chromatograhy (其它分离方法)
            };
            char InstModel[32];        // 型号
            char InstMarkNo[32];       // 设备号
            char InstManufacturer[48]; // 制造商
        };
    };

    // Condition:    //size=512+256
    union
    {
        BYTE Bytes[512 + 256];
        struct
        {
            int32_t ID;               // ID
            int32_t SignalNo;         // 信号通路号
            int32_t FromAIACDF;       // 是否来自AIACDF
            int32_t nReserve;         //(保留字段)
            char CatName[32];         // 样品名
            char InstName[32];        // 仪器名
            char AIACDFName[32];      // AIA-CDF文件名(不含扩展名)
            char Description[128];    // 说明(备注)
            char ExperimentTitle[64]; // 实验标题
            char DatasetOwner[64];    // 谱图数据属源(单位名称)
            char OperatorName[32];    // 操作者(分析员)
        };
    };
} TInstCondHead; // Size=256+(512+256)=1024

typedef struct tagTOvenCond // 柱箱条件
{
    // static Info:  //size=128
    union
    {
        TOvenInfo Info;
        struct
        {
            int32_t Available;    // 是否有效
            int32_t MaxTempRamps; // 最大程升阶数
            char Model[32];       // 型号
            double MaxTemp;       // 最高温度[K]
            double Equilibry;     // 平衡时间[min]
        };
    };

    // Condition:    //size=128
    union
    {
        BYTE Bytes[128];
        struct
        {
            double Temperature; // 柱温[K]
            int32_t TempMode;   // 柱温模式(0-Constant Temp, 1-Programmed)
        };
    };
} TOvenCond; // size=128+128

typedef struct tagTInletCond // 进样口条件
{
    // static Info:  //size=128
    union
    {
        TInletInfo Info;
        struct
        {
            int32_t Available;    // 是否有效
            int32_t Type;         // 类别(PIP-Packed Injection Port, SSL-Capillary Split/Splitless Inlet, ...)
            char TypeAbbr[8];     // 类别缩写
            char TypeName[32];    // 类别名
            int32_t InjMode;      // 进样方式(Manual, GSV-气体进样阀, Auto Sampler)
            int32_t ASType;       // 自动进样器分类码(暂不使用)
            double InjVolume;     // 定量管体积[uL]
            char InjectModel[32]; // 进样器型号         //2010-11-23: &&&&&&
            // BYTE    Reserve[32];
        };
    };

    // Condition:    //size=128
    union
    {
        BYTE Bytes[128];
        struct
        {
            int32_t TempMode;   // 进样口温度模式(0-Constant Temp, 1-Programmed(COC或PTV时))
            int32_t nReserve;   //(保留字段)
            int32_t SplitMode;  // 分流方式(Splitless, Split)
            int32_t PurgeOn;    // 是否隔膜清洗
            double Temperature; // 进样口温度[K]
            char CarrierGas[8]; // 载气(N2, H2, He, ...)
            double CarrierFlow; // 载气流速[mL/min]  // CarrierFlow = SplitFlow+PurgeFlow+ColumnFlow
            double Pressure;    // 进样口压力[psi]
            double SplitFlow;   // 分流流速[mL/min]
            char SplitRatio[8]; // 分流比
            double PurgeFlow;   // 隔膜清洗流速[mL/min]
            // 2016-11-10: &&&&&&
            union
            {
                double PurgeTime;     // 隔膜清洗时间[min]
                double SplitlessHold; // 不分流保持时间
            };
        };
    };
} TInletCond; // size=128+128

typedef struct tagTColumnCond // 色谱柱条件
{
    // static Info:  //size=128
    union
    {
        TColumnInfo Info;
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别(Packed, Capillary, Wide-Bore Capillary, HPLC Column,
            // GPC Column, IC Column, Unknown)
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            int32_t FreqIdx;   // 采样频率索引号(0-高速,1-快速,2-中速,3-慢速,4-低速)
            int32_t mmLength;  // 柱长[mm]
            double Diameter;   // 内径[mm]
            double FilmThick;  // 膜后[μm]
            double DeadTime;   // 死时间[min]
            char Model[32];    // 型号规格
        };
    };

    // Condition:    //size=128
    union
    {
        BYTE Bytes[128];
        struct
        {
            double Flow;     // 柱流量[mL/min]
            double Pressure; // 柱压[psi]
            int32_t PFMode;  // 柱压力/流量模式(Const Pressure, Const Flow, Programmed Pressure, Programmed Flow)
        };
    };
} TColumnCond; // size=128+128

typedef struct tagTDetectCond // 检测器条件
{
    // static Info:  //size=256
    union
    {
        TDetectInfo Info;
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别(FID, TCD, ECD, NPD, FPD, PID, HID-氦离子化检测器, MSD
            // UVD, RID, DAD, FD, ECD-电化学, CD-电导, ELSD-蒸发光散射)
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            char Model[32];    // 型号
            double RangeMax;   // 响应最大值
            double RangeMin;   // 响应最小值
            double RangeValue; // 检测量程[满偏检测量]
            // double  dReserve;       //(保留字段)          //2011-03-23: xxxxxx
            double Sensitivity;    // 检测灵敏度(以量程单位表示的检测量/lsb)    //2011-03-23: ++++++
            char DeteUnit[16];     // 检测单位                  //2011-03-23: &&&&&&
            char RangeOptions[96]; // 量程选项表
        };
    };

    // Condition:    //size=128
    union
    {
        BYTE Bytes[128];
        struct
        {
            union
            {
                struct
                {
                    double Temperature; // 检测器温度[K]
                    double H2Flow;      // H2流速[mL/min]
                    // 2012-10-30: &&&&&&
                    union
                    {
                        double AirFlow;   // Air流速[mL/min]
                        double RefFlow;   // TCD参考流速[mL/min]
                        double AnodeFlow; // ECD阳极流速[mL/min]
                    };

                    double Current;     // 检测器电流[mA, ECD为0.1nA]
                    char MakeupGas[16]; // 尾吹气体(N2, H2, He, Ar氩气, CH4, Unknown)
                    double MakeupFlow;  // 尾吹流速[mL/min]
                    int32_t MakeupMode; // 尾吹模式(makeup=const, col+makeup=const)
                    union
                    {
                        int32_t nReserve_x114; //(保留字段)
                        int32_t GC_RangeIDInc; // GC之FID/NPD/FPD的量程ID+1 (0x115及后续版本)
                    };
                }; // size=8*8
                struct
                {
                    double WaveLength;      // 检测波长[nm]
                    int32_t WaveLengthMode; // 波长模式(Constant, Programmed)
                };
                struct
                {
                    double SuppCurrent;    // 抑制器电流[mA]
                    int32_t SuppAvailable; // 抑制器是否有效
                };
            };
        };
    };
} TDetectCond; // size=256+128

typedef struct tagTAuxCond // 辅助区条件
{
    // static Info:  //size=128
    union
    {
        TAuxiliaryInfo Info;
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            char Model[32];    // 型号
            int32_t SensType;  // 传感类别(0-温度, 1-压力, 2-流量)
            int32_t OnOff;     // 开关状态          //2011-10-08: ++++++
            int32_t PosNo;     // 位置号(从1算起) //2011-09-20: ++++++
        };
    };

    // Condition:    //size=128
    union
    {
        BYTE Bytes[128];
        struct
        {
            double Temperature; // 温度[K]
            int32_t TempMode;   // 温度模式(0-Constant, 1-Programmed)
        };
        struct
        {
            double Pressure;  // 压力[psi]
            int32_t PresMode; // 压力模式(0-Constant, 1-Programmed)
        };
        // 2011-09-20: ++++++
        struct
        {
            double Flow;      // 流量[mL/min]
            int32_t FlowMode; // 流量模式(0-Constant, 1-Programmed)
        };
    };
} TAuxCond; // size=128+128

// 2011-09-20: ++++++
typedef struct tagTFloatRampItem // 单精度浮点数阶升数据项
{
    float RampRate;   // 升降速率[℃/min, psi/min, mL/min]
    float FinalValue; // 终值[K, psi, mL/min]
    float HoldTime;   // 保持时间[min]
    float TotalTime;  // 总计时间[min]
} TFloatRampItem;     // size = 16

// 2011-09-20: ++++++
#define _MaxAuxFloatRampItems_ 8
typedef struct tagTAuxCondEx // 扩充的辅助区条件
{
    // static Info:  //size=128
    union
    {
        TAuxiliaryInfo Info;
        struct
        {
            int32_t Available; // 是否有效
            int32_t Type;      // 类别(辅助加热区类型/辅助压力的气体类型)
            char TypeAbbr[8];  // 类别缩写
            char TypeName[32]; // 类别名
            char Model[32];    // 型号(即辅助区说明)
            int32_t SensType;  // 传感类别(0-温度, 1-压力, 2-流量)
            int32_t OnOff;     // 开关状态          //2011-10-08: ++++++
            int32_t PosNo;     // 位置号(从1算起) //2011-09-20: ++++++
        };
    };

    // Condition:    //size=128
    union
    {
        BYTE Bytes[128];
        TFloatRampItem RampItems[_MaxAuxFloatRampItems_]; // 阶升数据(含初时值, 温度-K, 压力-psi, 流量-mL/min)
    };
} TAuxCondEx; // size=128+128

typedef struct tagTPumpCond // 泵条件
{
    // static Info:  //size=128
    union
    {
        TPumpInfo Info;
        struct
        {
            int32_t Available;    // 是否有效
            int32_t Type;         // 类别(恒流, 二元梯度, 三元梯度, 四元梯度)
            int32_t GradPresMode; // 梯度压力模式(低压, 高压)
            int32_t nReserve;     //(保留字段)
            double MaxPressure;   // 最高压力[psi]
            double MinPressure;   // 最低压力[psi]
            char Model[32];       // 型号
        };
    };

    // Condition:    //size=256
    union
    {
        BYTE Bytes[256];
        struct
        {
            double TotalFlow;    // 泵流量[mL/min]
            double Pressure;     // 泵压[psi]
            double SolRatio[4];  // 溶剂配比[%]
            int32_t SolUsed[4];  // 溶剂是否被采用
            char SolName[4][32]; // 溶剂名称
            char FlowUnit[16];   // 泵流量单位[mL/min, …]
            char PresUnit[16];   // 泵压单位[Mpa, psi, bar]
        };
    };
} TPumpCond; // size=128+256

typedef struct tagTRampItem // 温度(压力/流量)升降程序
{
    double RampRate;   // 升降速率[℃/min, psi/min, mL/min]
    double FinalValue; // 终值[K, psi, mL/min]
    double HoldTime;   // 保持时间[min]
    double TotalTime;  // 总计时间[min]
} TRampItem;           // size = 32

typedef struct tagTPumpGradItem // 泵梯度程序
{
    double Time;        // 时间[min]
    double TotalFlow;   // 总流量[mL/min]
    double SolRatio[4]; // 各溶剂占的比率[%]
} TPumpGradItem;        // size = 48

typedef struct tagTWaveLengthItem // 波长程序
{
    double Time;     // 时间[min]
    int32_t Value;   // 波长
    BYTE Reserve[4]; //(保留字段)
} TWaveLengthItem;   // size = 16

// 关于仪器选项: ===================================================================
typedef struct tagTInstOptHead // 仪器选项定义
{
    int32_t type;     // 类别
    int32_t instMask; // 屏蔽码(...00000ILG ==> GC:0x01, LC:0x02, IC:0x04)
    char name[32];    // 名称
    char abbr[8];     // 缩写
    union
    {
        char detUnit[16];
        int32_t freqIdx; // 采样频率档次[0:高速(40Hz/20Hz), 1-常规(20Hz), 2-慢速(10Hz), 3-低速(5Hz)]
        BYTE Reserve[16];
    };
} TInstOptHead;
